import random

import numpy as np

s = [1, 2, 3, 4, 5]
e = enumerate(s)
#enumerate枚举s数组 enumerate可以获得迭代次数 index为次数
for index, value in e:
    print('%s, %s' % (index, value))
"""
0, 1
1, 2
2, 3
3, 4
4, 5
"""
#元组数组
a = [('q',4),('a',5),('v',6),('w',7),('z',9)]
for index, value in enumerate(a):
    a,b = value
    print(index,a,b)
"""
0 q 4
1 a 5
2 v 6
3 w 7
4 z 9
"""
#with使用open 方法的返回值赋值给变量 f，当离开 with 代码块的时候，系统会自动调用 f.close() 方法
file = "data.txt"
with open(file, "w") as f:
    f.write("hello python")
#列表的extend方法
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 使用 extend() 方法将 list2 的元素添加到 list1 的末尾
list1.extend(list2)

# 打印结果
print("00",list1)  # 输出: [1, 2, 3, 4, 5, 6]

#双除号 //代表整除即取结果的整数部分
print("01",10//3)
print("02",10/3)


"""集合
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
"""
basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print("03",basket)  # {'apple', 'orange', 'banana', 'pear'}
fruit = set(("apple", "banana", "cherry"))  # 请留意这个双括号
print("04",fruit)  # {'banana', 'apple', 'cherry'}
#random.sample
"""
random.sample用于从一个序列（例如列表、元组或字符串）中随机选取指定数量的不重复的元素。
dict['a'] 其中dict是一个字典，其中每个键是用户ID，而对应的值是一个列表或集合
random.sample(dict['a'], 1): 这表示从dict中随机选取一个元素。1表示我们只想要一个随机元素。
[0]: 这部分代码从上面提到的随机选取的元素中取出第一个元素。因为random.sample()返回的是一个列表，即使我们只选取了一个元素，它仍然是以列表的形式返回的
"""
dict = {'a': {1,2,3},'b':{4,5,6},'c':{7,8,8},'d':{9,9,9},}
i = random.sample(dict['a'], 1)[0]
print("05",i)

"""
*符号用于函数参数 允许输入任意数量的参数最后会收集到元组中
*tensors: 这是一个可变位置参数。它允许你传入任意数量的位置参数，并将它们收集到一个元组中
"""
def example_func(*args):
    for arg in args:
        print("06",arg)
example_func(1, 2, 3)  # 输出: 1 2 3

"""
** 用于收集关键字参数到一个字典中
**kwargs: 这是一个可变关键字参数。它允许你传入任意数量的关键字参数，并将它们收集到一个字典中。
"""
def example_func(**kwargs):
    for key, value in kwargs.items():
        print("07",f"{key} = {value}")
example_func(a=1, b=2)  # 输出: a = 1 b = 2
#* 用于收集位置参数到一个元组中，而 ** 用于收集关键字参数到一个字典中。 以下是一个混合使用的例子
def my_func(*args, **kwargs):
    print("Positional arguments:")
    for arg in args:
        print(arg)
    print("\nKeyword arguments:")
    for key, value in kwargs.items():
        print(f"{key} = {value}")
# 调用函数
my_func(1, 2, 3, a=4, b=5)
"""
Positional arguments:
1
2
3
Keyword arguments:
a = 4
b = 5
"""

"""
yield关键字 用于定义一个生成器函数。生成器函数是一种特殊类型的函数，它返回一个迭代器，
而不是一个值。这个迭代器可以在需要时产生一个值，而不是一次性计算所有值。
每次调用generate_numbers函数时 yield返回数但函数不停止继续执行n += 1
"""
def generate_numbers():
    n = 1
    while True:
        yield n
        n += 1
odd_gen = generate_numbers()  # 生成奇数
even_gen = generate_numbers()  # 生成偶数
# 获取前几个奇数和偶数
print(next(odd_gen))  # 输出: 1 (奇数)
print(next(even_gen))  # 输出: 2 (偶数)
print(next(odd_gen))  # 输出: 3 (奇数)
print(next(even_gen))  # 输出: 4 (偶数)

#在python中数字0可以代表false 非0代表true
list1 = [0,1,-1]
for i in list1:
    if i:
        print("true")
    else:
        print("false")
#输出false true true


#@staticmethod表示这个方法是一个静态方法 调用方法时就不用实例化
class Calculator:
    @staticmethod
    def add(a, b):
        return a + b
#不用实例化
result = Calculator.add(3, 4)
print("07",result)  # 输出: 7

#数组的pop方法 移除列表中的最后一个元素，并返回该元素。在这里，它返回整数 3。
list1 = [0,1,2,3]
print("08",list1.pop())

exclude_index = []
exclude_items = []
range_i = 1
items = [1, 2, 3]
for i in range(5):
    exclude_index.extend([range_i] * len(items))
    exclude_items.extend(items)
print("09",exclude_index,"\n10",exclude_items)
"""
09 [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] 
10 [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]
"""
#移位运算1<<10将数字1左移10位，产生一个二进制数，然后取其负值。
print("10",-(1<<10))#输出1024

import multiprocessing

#python的lambda关键字，用于定义一个简单的匿名函数
# 定义一个lambda函数，该函数不接受任何参数，并返回5
f = lambda: 5
print("11",f())  # 输出：5
# 定义一个lambda函数，该函数接受一个参数并返回它的平方
f = lambda x: x ** 2
print("12",f(3))  # 输出：9

#Python的map()函数是内置函数之一，用于将一个函数应用于可迭代对象的所有元素。
#其语法为map(function, iterable1, iterable2, ...)。map()函数将function函数应用于iterable1的所有元素，然后应用于iterable2的所有元素，以此类推
square = lambda  x:x**2
numbers = [1, 2, 3, 4, 5]
squared = map(square, numbers)
#将最终结果转为list
print("13",list(squared))  # 输出：[1, 4, 9, 16, 25]

#map和lambda多参数使用 定义一个lambda函数，该函数接受两个参数并返回它们的乘积
mul = lambda x, y: x * y
# 使用map和lambda函数将列表中的每个元素乘以2
#pred = list(map(lambda x: x in groundTrue, predictTopK))
list1 = [1,2,3,4,9]
list2 = [1,3,5,7,9]
"""
list2是一个可迭代对象 
lambda x: x in list1 对迭代对象x进行遍历 判断x是否存在list1中
下面语句用于判断list2的每个元素是否存在list1中
"""
double = list(map(lambda x: x in list1, list2))
print("14",double)  # [True, True, False, False, True]
r = []
pred = np.array(double).astype("float")
r.append(pred)
print(np.array(r).astype('float'))

#defaultdict 使用
from collections import defaultdict
#defaultdict它类似于普通的字典，但当访问一个不存在的键时，它会返回一个默认值，而不是抛出 KeyError。
# 创建一个默认值为0的defaultdict，用于计数
counter = defaultdict(int)
# 增加计数
counter['apple'] += 1
#访问一个不存在的键返回默认值0
print("15",counter['banana'])  # 0

#exec 和 eval
"""
exec 用于执行存储在字符串或对象中的 Python 代码。没有返回结果
eval 用于计算存储在字符串中的 Python 表达式并返回结果。
"""
code_in_string = "print('16exec Hello, World!')"
exec(code_in_string)
expression = "1 + 2"
result = eval(expression)
print("17eval",result)  # 输出: 3

#交集
#intersection()是集合的一个方法，用于找出两个集合中都存在的元素。这个操作会返回一个集合，其中包含在items和predicted中都出现的元素。
hit = set([0,1,2,3,4]).intersection(set([2,3,4,5,6,7,8,9,10,11]))
print("18",hit) #{2, 3, 4}

#round四舍五入函数 对小数点后三位进行四舍五入
x = 3.456789
rounded_value = round(x, 3)
print("19",rounded_value)  # 输出：3.457

"""
    集合difference使用 和random.sample方法使用
    random.sample(a.difference(b)将返回一个集合，其中包含在a中但不在b中的元素
    random.sample(population, k) population一个序列（列表、元组等），你想要从中随机选择元素 k表示你想要从population中选择的元素数量
    random.sample(xxx,1)[0] 因为random.sample返回一个列表 我们只要一个元素所以只要列表中的第一个元素
    neg_item返回一个b中没有出现过但在a中出现过的序号 
"""
a = set([2,3,4,5,6,7,8,9,10,11])
b = set([0,1,2,3,4])
neg_item = random.sample(a.difference(b), 1)[0]
print("20",neg_item)

dict = {'a': {1,2,3},'b':{4,5,6},'c':{7,8,8},'d':{9,9,9},}
for a,b in dict.items():
    print("a ",a,"b ",b)

#字符串比较
str1 = "hello"
str2 = "world"
str3 = "hello"

if str1 == str3:
    print("21","str1 and str3 are equal")
else:
    print("21","str1 and str3 are not equal")
